/**
 * 模板数据初始化工具
 * 将 public/template.json 的数据导入到数据库
 */

import { getDb } from '@/lib/db';
import { SDTemplate, TemplateType } from '@/types/templates';
import { validateTemplate } from '@/utils/templateValidation';
import fs from 'fs';
import path from 'path';

const COLLECTION_NAME = 'sd_templates';

interface TemplateJsonData {
  txt2img: any[];
  img2img: any[];
  postprocess: any[];
}

/**
 * 从 template.json 读取数据
 */
export async function loadTemplateJson(): Promise<TemplateJsonData> {
  const templatePath = path.join(process.cwd(), 'public', 'template.json');
  
  if (!fs.existsSync(templatePath)) {
    throw new Error('template.json 文件不存在');
  }
  
  const jsonContent = fs.readFileSync(templatePath, 'utf-8');
  return JSON.parse(jsonContent);
}

/**
 * 转换 template.json 数据为标准格式
 */
export function transformTemplateData(jsonData: TemplateJsonData): SDTemplate[] {
  const templates: SDTemplate[] = [];
  const now = new Date().toISOString();
  
  // 处理 txt2img 模板
  jsonData.txt2img.forEach(item => {
    const template: SDTemplate = {
      ...item,
      type: TemplateType.TXT2IMG,
      created_at: now,
      updated_at: now
    };
    templates.push(template);
  });
  
  // 处理 img2img 模板
  jsonData.img2img.forEach(item => {
    const template: SDTemplate = {
      ...item,
      type: TemplateType.IMG2IMG,
      created_at: now,
      updated_at: now
    };
    templates.push(template);
  });
  
  // 处理 postprocess 模板
  jsonData.postprocess.forEach(item => {
    const template: SDTemplate = {
      ...item,
      type: TemplateType.POSTPROCESS,
      created_at: now,
      updated_at: now
    };
    templates.push(template);
  });
  
  return templates;
}

/**
 * 验证模板数据
 */
export function validateTemplates(templates: SDTemplate[]): {
  valid: SDTemplate[];
  invalid: { template: SDTemplate; errors: any[] }[];
} {
  const valid: SDTemplate[] = [];
  const invalid: { template: SDTemplate; errors: any[] }[] = [];
  
  templates.forEach(template => {
    const validation = validateTemplate(template);
    if (validation.isValid) {
      valid.push(template);
    } else {
      invalid.push({ template, errors: validation.errors });
    }
  });
  
  return { valid, invalid };
}

/**
 * 初始化模板数据到数据库
 */
export async function initTemplateData(options: {
  clearExisting?: boolean;
  skipValidation?: boolean;
} = {}): Promise<{
  success: boolean;
  imported: number;
  skipped: number;
  errors: string[];
}> {
  const { clearExisting = false, skipValidation = false } = options;
  const errors: string[] = [];
  let imported = 0;
  let skipped = 0;
  
  try {
    // 连接数据库
    const db = await getDb();
    
    // 清空现有数据（如果需要）
    if (clearExisting) {
      console.log('清空现有模板数据...');
      await db.deleteMany(COLLECTION_NAME, {});
    }
    
    // 读取 template.json
    console.log('读取 template.json...');
    const jsonData = await loadTemplateJson();
    
    // 转换数据格式
    console.log('转换数据格式...');
    const templates = transformTemplateData(jsonData);
    console.log(`共找到 ${templates.length} 个模板`);
    
    // 验证数据（如果需要）
    let validTemplates = templates;
    if (!skipValidation) {
      console.log('验证模板数据...');
      const { valid, invalid } = validateTemplates(templates);
      validTemplates = valid;
      
      if (invalid.length > 0) {
        console.warn(`发现 ${invalid.length} 个无效模板:`);
        invalid.forEach(({ template, errors: validationErrors }) => {
          const errorMsg = `模板 ${template.id}: ${validationErrors.map(e => e.message).join(', ')}`;
          console.warn(errorMsg);
          errors.push(errorMsg);
        });
      }
    }
    
    // 导入数据
    console.log(`开始导入 ${validTemplates.length} 个有效模板...`);
    
    for (const template of validTemplates) {
      try {
        // 检查是否已存在
        const existing = await db.findOne(COLLECTION_NAME, { id: template.id });
        
        if (existing.data) {
          if (!clearExisting) {
            console.log(`跳过已存在的模板: ${template.id}`);
            skipped++;
            continue;
          }
        }
        
        // 创建模板
        const result = await db.create(COLLECTION_NAME, template as any);
        
        if (result.success) {
          console.log(`导入成功: ${template.id} - ${template.name}`);
          imported++;
        } else {
          const errorMsg = `导入失败: ${template.id} - ${result.error}`;
          console.error(errorMsg);
          errors.push(errorMsg);
        }
        
      } catch (error: any) {
        const errorMsg = `导入模板 ${template.id} 时发生错误: ${error.message}`;
        console.error(errorMsg);
        errors.push(errorMsg);
      }
    }
    
    console.log(`数据初始化完成: 导入 ${imported} 个，跳过 ${skipped} 个，错误 ${errors.length} 个`);
    
    return {
      success: errors.length === 0,
      imported,
      skipped,
      errors
    };
    
  } catch (error: any) {
    const errorMsg = `数据初始化失败: ${error.message}`;
    console.error(errorMsg);
    errors.push(errorMsg);
    
    return {
      success: false,
      imported,
      skipped,
      errors
    };
  }
}

/**
 * 导出模板数据到 JSON 文件
 */
export async function exportTemplateData(outputPath?: string): Promise<{
  success: boolean;
  exported: number;
  filePath?: string;
  error?: string;
}> {
  try {
    const db = await getDb();
    
    // 获取所有模板
    const result = await db.findMany(COLLECTION_NAME, {});
    
    if (!result.success || !result.data) {
      return {
        success: false,
        exported: 0,
        error: result.error || '获取模板数据失败'
      };
    }
    
    const templates = result.data as SDTemplate[];
    
    // 按类型分组
    const groupedData: TemplateJsonData = {
      txt2img: [],
      img2img: [],
      postprocess: []
    };
    
    templates.forEach(template => {
      // 移除数据库特有字段
      const { created_at, updated_at, type, ...templateData } = template as any;
      
      switch (type) {
        case TemplateType.TXT2IMG:
          groupedData.txt2img.push(templateData);
          break;
        case TemplateType.IMG2IMG:
          groupedData.img2img.push(templateData);
          break;
        case TemplateType.POSTPROCESS:
          groupedData.postprocess.push(templateData);
          break;
      }
    });
    
    // 写入文件
    const filePath = outputPath || path.join(process.cwd(), 'public', 'template_export.json');
    fs.writeFileSync(filePath, JSON.stringify(groupedData, null, 2), 'utf-8');
    
    console.log(`模板数据已导出到: ${filePath}`);
    console.log(`导出统计: txt2img(${groupedData.txt2img.length}), img2img(${groupedData.img2img.length}), postprocess(${groupedData.postprocess.length})`);
    
    return {
      success: true,
      exported: templates.length,
      filePath
    };
    
  } catch (error: any) {
    return {
      success: false,
      exported: 0,
      error: error.message
    };
  }
}